import 'dart:io';
import 'package:flutter/foundation.dart';
import 'package:path_provider/path_provider.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:photo_manager/photo_manager.dart';
import 'dart:convert';

/// 备份去重服务
/// 实现多层去重逻辑，避免重复上传相同文件
class BackupDeduplicationService {
  // 单例模式
  static final BackupDeduplicationService _instance =
      BackupDeduplicationService._internal();
  factory BackupDeduplicationService() => _instance;
  BackupDeduplicationService._internal();

  // 缓存已上传文件的信息
  // Map结构: <文件大小_最后修改时间, 文件名>
  final Map<String, String> _uploadedFileCache = {};

  // 缓存是否已初始化
  bool _isInitialized = false;

  // 最后一次同步时间
  DateTime? _lastSyncTime;

  // SharedPreferences键名
  final String _cacheKey = 'uploaded_files_cache';

  /// 获取服务初始化状态
  bool get isInitialized => _isInitialized;

  /// 获取缓存中的文件数量
  int get cachedFileCount => _uploadedFileCache.length;

  /// 获取最后同步时间
  DateTime? get lastSyncTime => _lastSyncTime;

  /// 初始化服务，加载本地缓存
  Future<void> initialize() async {
    if (_isInitialized) return;

    try {
      debugPrint('正在初始化备份去重服务...');

      // 从SharedPreferences加载缓存数据
      final prefs = await SharedPreferences.getInstance();
      final cacheData = prefs.getString(_cacheKey);

      if (cacheData != null && cacheData.isNotEmpty) {
        final Map<String, dynamic> decoded = jsonDecode(cacheData);

        // 转换为所需的Map格式
        _uploadedFileCache.clear();
        decoded.forEach((key, value) {
          _uploadedFileCache[key] = value.toString();
        });

        // 获取最后同步时间
        final lastSyncTimeStr = prefs.getString('${_cacheKey}_last_sync');
        if (lastSyncTimeStr != null) {
          _lastSyncTime = DateTime.parse(lastSyncTimeStr);
        }

        debugPrint('已从本地缓存加载${_uploadedFileCache.length}条文件记录');
        debugPrint('最后同步时间: ${_lastSyncTime?.toIso8601String() ?? "从未同步"}');
      } else {
        debugPrint('未找到本地缓存数据，使用空缓存');
      }

      _isInitialized = true;
    } catch (e) {
      debugPrint('初始化备份去重服务失败: $e');
      // 出错时使用空缓存
      _uploadedFileCache.clear();
      _isInitialized = true;
    }
  }

  /// 保存缓存到本地存储
  Future<void> _saveCache() async {
    try {
      final prefs = await SharedPreferences.getInstance();

      // 编码为JSON字符串
      final jsonData = jsonEncode(_uploadedFileCache);

      // 保存缓存数据
      await prefs.setString(_cacheKey, jsonData);

      // 更新最后同步时间
      final now = DateTime.now();
      await prefs.setString('${_cacheKey}_last_sync', now.toIso8601String());
      _lastSyncTime = now;

      debugPrint('已保存${_uploadedFileCache.length}条文件记录到本地缓存');
    } catch (e) {
      debugPrint('保存备份去重缓存失败: $e');
    }
  }

  /// 清除缓存
  Future<void> clearCache() async {
    try {
      _uploadedFileCache.clear();

      final prefs = await SharedPreferences.getInstance();
      await prefs.remove(_cacheKey);
      await prefs.remove('${_cacheKey}_last_sync');
      _lastSyncTime = null;

      debugPrint('已清除备份去重缓存');
    } catch (e) {
      debugPrint('清除备份去重缓存失败: $e');
    }
  }

  /// 添加已上传文件信息到缓存
  Future<void> addUploadedFile(File file) async {
    if (!_isInitialized) await initialize();

    try {
      final fileStats = file.statSync();
      final fileSize = fileStats.size;
      final modifiedTime = fileStats.modified.millisecondsSinceEpoch;

      // 创建缓存键: 文件大小_修改时间
      final cacheKey = '${fileSize}_$modifiedTime';

      // 添加到缓存
      _uploadedFileCache[cacheKey] = file.path;

      // 每添加10个文件保存一次缓存
      if (_uploadedFileCache.length % 10 == 0) {
        await _saveCache();
      }
    } catch (e) {
      debugPrint('添加已上传文件到缓存失败: $e');
    }
  }

  /// 批量添加已上传文件信息到缓存
  Future<void> addUploadedFiles(List<File> files) async {
    if (!_isInitialized) await initialize();

    try {
      for (final file in files) {
        final fileStats = file.statSync();
        final fileSize = fileStats.size;
        final modifiedTime = fileStats.modified.millisecondsSinceEpoch;

        // 创建缓存键: 文件大小_修改时间
        final cacheKey = '${fileSize}_$modifiedTime';

        // 添加到缓存
        _uploadedFileCache[cacheKey] = file.path;
      }

      // 保存缓存
      await _saveCache();

      debugPrint('已批量添加${files.length}个文件到缓存');
    } catch (e) {
      debugPrint('批量添加已上传文件到缓存失败: $e');
    }
  }

  /// 检查资产是否为重复文件 (第一层去重)
  /// 基于文件大小和最后修改时间判断
  Future<bool> isFileDuplicate(AssetEntity asset) async {
    if (!_isInitialized) await initialize();

    try {
      // 获取文件引用
      final file = await asset.file;
      if (file == null) {
        debugPrint('无法获取资产文件引用，无法进行去重检查');
        return false;
      }

      // 获取文件基本信息
      final fileStats = file.statSync();
      final fileSize = fileStats.size;
      final modifiedTime = fileStats.modified.millisecondsSinceEpoch;

      // 构建缓存键
      final cacheKey = '${fileSize}_$modifiedTime';

      // 检查是否在缓存中
      final isDuplicate = _uploadedFileCache.containsKey(cacheKey);

      if (isDuplicate) {
        debugPrint('检测到重复文件: ${file.path}，大小: $fileSize，修改时间: $modifiedTime');
      }

      return isDuplicate;
    } catch (e) {
      debugPrint('检查文件是否重复失败: $e');
      return false; // 出错时假设不是重复文件
    }
  }

  /// 批量检查资产是否为重复文件
  /// 返回过滤后的非重复资产列表
  Future<List<AssetEntity>> filterDuplicateAssets(
    List<AssetEntity> assets,
  ) async {
    if (!_isInitialized) await initialize();

    final List<AssetEntity> uniqueAssets = [];

    for (final asset in assets) {
      final isDuplicate = await isFileDuplicate(asset);
      if (!isDuplicate) {
        uniqueAssets.add(asset);
      }
    }

    debugPrint('批量去重: 输入${assets.length}个资产，过滤出${uniqueAssets.length}个非重复资产');

    return uniqueAssets;
  }

  /// 强制保存缓存到本地
  Future<void> forceSaveCache() async {
    await _saveCache();
  }
}
